// $ANTLR 3.2 Sep 23, 2009 12:02:23 Acd.g 2010-01-18 20:27:02

package net.bioteam.appweb.acd;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;


import org.antlr.runtime.tree.*;

public class AcdParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "DQ", "COLON", "BRACKETLEFT", "BRACKETRIGHT", "PARAMETER", "SECTION", "ATTRIBUTE", "PROGRAM", "ID", "ATTRVALUE", "LETTER", "WS", "LINE_COMMENT", "VARIABLE", "'section'", "'endsection'"
    };
    public static final int BRACKETLEFT=6;
    public static final int SECTION=9;
    public static final int ATTRVALUE=13;
    public static final int LINE_COMMENT=16;
    public static final int LETTER=14;
    public static final int ATTRIBUTE=10;
    public static final int DQ=4;
    public static final int ID=12;
    public static final int EOF=-1;
    public static final int BRACKETRIGHT=7;
    public static final int COLON=5;
    public static final int T__19=19;
    public static final int WS=15;
    public static final int T__18=18;
    public static final int VARIABLE=17;
    public static final int PARAMETER=8;
    public static final int PROGRAM=11;

    // delegates
    // delegators


        public AcdParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public AcdParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return AcdParser.tokenNames; }
    public String getGrammarFileName() { return "Acd.g"; }


    	protected void mismatch(IntStream input, int ttype, BitSet follow)
    	throws RecognitionException
    	{
    		throw new MismatchedTokenException(ttype, input);
    	}
    	public Object recoverFromMismatchedSet(IntStream input,
    		RecognitionException e,
    		BitSet follow)
    	throws RecognitionException
    	{
    		throw e;
    	}


    public static class program_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "program"
    // Acd.g:46:1: program : ( programcontent )* -> ^( PROGRAM ( programcontent )* ) ;
    public final AcdParser.program_return program() throws RecognitionException {
        AcdParser.program_return retval = new AcdParser.program_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AcdParser.programcontent_return programcontent1 = null;


        RewriteRuleSubtreeStream stream_programcontent=new RewriteRuleSubtreeStream(adaptor,"rule programcontent");
        try {
            // Acd.g:46:9: ( ( programcontent )* -> ^( PROGRAM ( programcontent )* ) )
            // Acd.g:46:11: ( programcontent )*
            {
            // Acd.g:46:11: ( programcontent )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==ID||LA1_0==18) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // Acd.g:46:11: programcontent
            	    {
            	    pushFollow(FOLLOW_programcontent_in_program94);
            	    programcontent1=programcontent();

            	    state._fsp--;

            	    stream_programcontent.add(programcontent1.getTree());

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);



            // AST REWRITE
            // elements: programcontent
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 46:26: -> ^( PROGRAM ( programcontent )* )
            {
                // Acd.g:46:28: ^( PROGRAM ( programcontent )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PROGRAM, "PROGRAM"), root_1);

                // Acd.g:46:38: ( programcontent )*
                while ( stream_programcontent.hasNext() ) {
                    adaptor.addChild(root_1, stream_programcontent.nextTree());

                }
                stream_programcontent.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException e11) {
        	throw e11;
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "program"

    public static class programcontent_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "programcontent"
    // Acd.g:48:1: programcontent : ( parameter | section );
    public final AcdParser.programcontent_return programcontent() throws RecognitionException {
        AcdParser.programcontent_return retval = new AcdParser.programcontent_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AcdParser.parameter_return parameter2 = null;

        AcdParser.section_return section3 = null;



        try {
            // Acd.g:48:15: ( parameter | section )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==ID) ) {
                alt2=1;
            }
            else if ( (LA2_0==18) ) {
                alt2=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // Acd.g:48:16: parameter
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_parameter_in_programcontent108);
                    parameter2=parameter();

                    state._fsp--;

                    root_0 = (Object)adaptor.becomeRoot(parameter2.getTree(), root_0);

                    }
                    break;
                case 2 :
                    // Acd.g:48:27: section
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_section_in_programcontent111);
                    section3=section();

                    state._fsp--;

                    root_0 = (Object)adaptor.becomeRoot(section3.getTree(), root_0);

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException e11) {
        	throw e11;
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "programcontent"

    public static class section_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "section"
    // Acd.g:51:1: section : s= 'section' COLON e= ID BRACKETLEFT ( attribute )* BRACKETRIGHT ( sectioncontent )* 'endsection' COLON e1= ID -> ^( SECTION[$s] $e ( attribute )* ( sectioncontent )* ) ;
    public final AcdParser.section_return section() throws RecognitionException {
        AcdParser.section_return retval = new AcdParser.section_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token s=null;
        Token e=null;
        Token e1=null;
        Token COLON4=null;
        Token BRACKETLEFT5=null;
        Token BRACKETRIGHT7=null;
        Token string_literal9=null;
        Token COLON10=null;
        AcdParser.attribute_return attribute6 = null;

        AcdParser.sectioncontent_return sectioncontent8 = null;


        Object s_tree=null;
        Object e_tree=null;
        Object e1_tree=null;
        Object COLON4_tree=null;
        Object BRACKETLEFT5_tree=null;
        Object BRACKETRIGHT7_tree=null;
        Object string_literal9_tree=null;
        Object COLON10_tree=null;
        RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
        RewriteRuleTokenStream stream_BRACKETLEFT=new RewriteRuleTokenStream(adaptor,"token BRACKETLEFT");
        RewriteRuleTokenStream stream_19=new RewriteRuleTokenStream(adaptor,"token 19");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_18=new RewriteRuleTokenStream(adaptor,"token 18");
        RewriteRuleTokenStream stream_BRACKETRIGHT=new RewriteRuleTokenStream(adaptor,"token BRACKETRIGHT");
        RewriteRuleSubtreeStream stream_sectioncontent=new RewriteRuleSubtreeStream(adaptor,"rule sectioncontent");
        RewriteRuleSubtreeStream stream_attribute=new RewriteRuleSubtreeStream(adaptor,"rule attribute");
        try {
            // Acd.g:51:9: (s= 'section' COLON e= ID BRACKETLEFT ( attribute )* BRACKETRIGHT ( sectioncontent )* 'endsection' COLON e1= ID -> ^( SECTION[$s] $e ( attribute )* ( sectioncontent )* ) )
            // Acd.g:51:11: s= 'section' COLON e= ID BRACKETLEFT ( attribute )* BRACKETRIGHT ( sectioncontent )* 'endsection' COLON e1= ID
            {
            s=(Token)match(input,18,FOLLOW_18_in_section124);  
            stream_18.add(s);

            COLON4=(Token)match(input,COLON,FOLLOW_COLON_in_section126);  
            stream_COLON.add(COLON4);

            e=(Token)match(input,ID,FOLLOW_ID_in_section130);  
            stream_ID.add(e);

            BRACKETLEFT5=(Token)match(input,BRACKETLEFT,FOLLOW_BRACKETLEFT_in_section132);  
            stream_BRACKETLEFT.add(BRACKETLEFT5);

            // Acd.g:51:46: ( attribute )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0==ID) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // Acd.g:51:46: attribute
            	    {
            	    pushFollow(FOLLOW_attribute_in_section134);
            	    attribute6=attribute();

            	    state._fsp--;

            	    stream_attribute.add(attribute6.getTree());

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);

            BRACKETRIGHT7=(Token)match(input,BRACKETRIGHT,FOLLOW_BRACKETRIGHT_in_section137);  
            stream_BRACKETRIGHT.add(BRACKETRIGHT7);

            // Acd.g:51:70: ( sectioncontent )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==ID||LA4_0==18) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // Acd.g:51:70: sectioncontent
            	    {
            	    pushFollow(FOLLOW_sectioncontent_in_section139);
            	    sectioncontent8=sectioncontent();

            	    state._fsp--;

            	    stream_sectioncontent.add(sectioncontent8.getTree());

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);

            string_literal9=(Token)match(input,19,FOLLOW_19_in_section142);  
            stream_19.add(string_literal9);

            COLON10=(Token)match(input,COLON,FOLLOW_COLON_in_section144);  
            stream_COLON.add(COLON10);

            e1=(Token)match(input,ID,FOLLOW_ID_in_section148);  
            stream_ID.add(e1);



            // AST REWRITE
            // elements: attribute, sectioncontent, e
            // token labels: e
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleTokenStream stream_e=new RewriteRuleTokenStream(adaptor,"token e",e);
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 52:2: -> ^( SECTION[$s] $e ( attribute )* ( sectioncontent )* )
            {
                // Acd.g:52:4: ^( SECTION[$s] $e ( attribute )* ( sectioncontent )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(SECTION, s), root_1);

                adaptor.addChild(root_1, stream_e.nextNode());
                // Acd.g:52:21: ( attribute )*
                while ( stream_attribute.hasNext() ) {
                    adaptor.addChild(root_1, stream_attribute.nextTree());

                }
                stream_attribute.reset();
                // Acd.g:52:32: ( sectioncontent )*
                while ( stream_sectioncontent.hasNext() ) {
                    adaptor.addChild(root_1, stream_sectioncontent.nextTree());

                }
                stream_sectioncontent.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException e11) {
        	throw e11;
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "section"

    public static class sectioncontent_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "sectioncontent"
    // Acd.g:54:1: sectioncontent : ( parameter | section );
    public final AcdParser.sectioncontent_return sectioncontent() throws RecognitionException {
        AcdParser.sectioncontent_return retval = new AcdParser.sectioncontent_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        AcdParser.parameter_return parameter11 = null;

        AcdParser.section_return section12 = null;



        try {
            // Acd.g:54:15: ( parameter | section )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==ID) ) {
                alt5=1;
            }
            else if ( (LA5_0==18) ) {
                alt5=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // Acd.g:54:16: parameter
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_parameter_in_sectioncontent171);
                    parameter11=parameter();

                    state._fsp--;

                    root_0 = (Object)adaptor.becomeRoot(parameter11.getTree(), root_0);

                    }
                    break;
                case 2 :
                    // Acd.g:54:28: section
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_section_in_sectioncontent175);
                    section12=section();

                    state._fsp--;

                    root_0 = (Object)adaptor.becomeRoot(section12.getTree(), root_0);

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException e11) {
        	throw e11;
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "sectioncontent"

    public static class parameter_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parameter"
    // Acd.g:56:1: parameter : t= ID COLON n= ID BRACKETLEFT ( attribute )* BRACKETRIGHT -> ^( PARAMETER[$t, \"parameter\"] $t $n ( attribute )* ) ;
    public final AcdParser.parameter_return parameter() throws RecognitionException {
        AcdParser.parameter_return retval = new AcdParser.parameter_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token t=null;
        Token n=null;
        Token COLON13=null;
        Token BRACKETLEFT14=null;
        Token BRACKETRIGHT16=null;
        AcdParser.attribute_return attribute15 = null;


        Object t_tree=null;
        Object n_tree=null;
        Object COLON13_tree=null;
        Object BRACKETLEFT14_tree=null;
        Object BRACKETRIGHT16_tree=null;
        RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
        RewriteRuleTokenStream stream_BRACKETLEFT=new RewriteRuleTokenStream(adaptor,"token BRACKETLEFT");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
        RewriteRuleTokenStream stream_BRACKETRIGHT=new RewriteRuleTokenStream(adaptor,"token BRACKETRIGHT");
        RewriteRuleSubtreeStream stream_attribute=new RewriteRuleSubtreeStream(adaptor,"rule attribute");
        try {
            // Acd.g:56:11: (t= ID COLON n= ID BRACKETLEFT ( attribute )* BRACKETRIGHT -> ^( PARAMETER[$t, \"parameter\"] $t $n ( attribute )* ) )
            // Acd.g:56:13: t= ID COLON n= ID BRACKETLEFT ( attribute )* BRACKETRIGHT
            {
            t=(Token)match(input,ID,FOLLOW_ID_in_parameter186);  
            stream_ID.add(t);

            COLON13=(Token)match(input,COLON,FOLLOW_COLON_in_parameter188);  
            stream_COLON.add(COLON13);

            n=(Token)match(input,ID,FOLLOW_ID_in_parameter192);  
            stream_ID.add(n);

            BRACKETLEFT14=(Token)match(input,BRACKETLEFT,FOLLOW_BRACKETLEFT_in_parameter194);  
            stream_BRACKETLEFT.add(BRACKETLEFT14);

            // Acd.g:56:41: ( attribute )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==ID) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // Acd.g:56:41: attribute
            	    {
            	    pushFollow(FOLLOW_attribute_in_parameter196);
            	    attribute15=attribute();

            	    state._fsp--;

            	    stream_attribute.add(attribute15.getTree());

            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);

            BRACKETRIGHT16=(Token)match(input,BRACKETRIGHT,FOLLOW_BRACKETRIGHT_in_parameter199);  
            stream_BRACKETRIGHT.add(BRACKETRIGHT16);



            // AST REWRITE
            // elements: n, t, attribute
            // token labels: t, n
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleTokenStream stream_t=new RewriteRuleTokenStream(adaptor,"token t",t);
            RewriteRuleTokenStream stream_n=new RewriteRuleTokenStream(adaptor,"token n",n);
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 57:2: -> ^( PARAMETER[$t, \"parameter\"] $t $n ( attribute )* )
            {
                // Acd.g:57:4: ^( PARAMETER[$t, \"parameter\"] $t $n ( attribute )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMETER, t, "parameter"), root_1);

                adaptor.addChild(root_1, stream_t.nextNode());
                adaptor.addChild(root_1, stream_n.nextNode());
                // Acd.g:57:39: ( attribute )*
                while ( stream_attribute.hasNext() ) {
                    adaptor.addChild(root_1, stream_attribute.nextTree());

                }
                stream_attribute.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException e11) {
        	throw e11;
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "parameter"

    public static class attribute_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "attribute"
    // Acd.g:58:1: attribute : n= ID COLON ( ATTRVALUE )? -> ^( ATTRIBUTE[$n, \"attribute\"] ID ( ATTRVALUE )? ) ;
    public final AcdParser.attribute_return attribute() throws RecognitionException {
        AcdParser.attribute_return retval = new AcdParser.attribute_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token n=null;
        Token COLON17=null;
        Token ATTRVALUE18=null;

        Object n_tree=null;
        Object COLON17_tree=null;
        Object ATTRVALUE18_tree=null;
        RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
        RewriteRuleTokenStream stream_ATTRVALUE=new RewriteRuleTokenStream(adaptor,"token ATTRVALUE");
        RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");

        try {
            // Acd.g:58:11: (n= ID COLON ( ATTRVALUE )? -> ^( ATTRIBUTE[$n, \"attribute\"] ID ( ATTRVALUE )? ) )
            // Acd.g:58:13: n= ID COLON ( ATTRVALUE )?
            {
            n=(Token)match(input,ID,FOLLOW_ID_in_attribute225);  
            stream_ID.add(n);

            COLON17=(Token)match(input,COLON,FOLLOW_COLON_in_attribute227);  
            stream_COLON.add(COLON17);

            // Acd.g:58:24: ( ATTRVALUE )?
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==ATTRVALUE) ) {
                alt7=1;
            }
            switch (alt7) {
                case 1 :
                    // Acd.g:58:24: ATTRVALUE
                    {
                    ATTRVALUE18=(Token)match(input,ATTRVALUE,FOLLOW_ATTRVALUE_in_attribute229);  
                    stream_ATTRVALUE.add(ATTRVALUE18);


                    }
                    break;

            }



            // AST REWRITE
            // elements: ID, ATTRVALUE
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 58:35: -> ^( ATTRIBUTE[$n, \"attribute\"] ID ( ATTRVALUE )? )
            {
                // Acd.g:58:37: ^( ATTRIBUTE[$n, \"attribute\"] ID ( ATTRVALUE )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ATTRIBUTE, n, "attribute"), root_1);

                adaptor.addChild(root_1, stream_ID.nextNode());
                // Acd.g:58:69: ( ATTRVALUE )?
                if ( stream_ATTRVALUE.hasNext() ) {
                    adaptor.addChild(root_1, stream_ATTRVALUE.nextNode());

                }
                stream_ATTRVALUE.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;
            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException e11) {
        	throw e11;
        }
        finally {
        }
        return retval;
    }
    // $ANTLR end "attribute"

    // Delegated rules


 

    public static final BitSet FOLLOW_programcontent_in_program94 = new BitSet(new long[]{0x0000000000041002L});
    public static final BitSet FOLLOW_parameter_in_programcontent108 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_section_in_programcontent111 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_18_in_section124 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_COLON_in_section126 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_ID_in_section130 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_BRACKETLEFT_in_section132 = new BitSet(new long[]{0x0000000000001080L});
    public static final BitSet FOLLOW_attribute_in_section134 = new BitSet(new long[]{0x0000000000001080L});
    public static final BitSet FOLLOW_BRACKETRIGHT_in_section137 = new BitSet(new long[]{0x00000000000C1000L});
    public static final BitSet FOLLOW_sectioncontent_in_section139 = new BitSet(new long[]{0x00000000000C1000L});
    public static final BitSet FOLLOW_19_in_section142 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_COLON_in_section144 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_ID_in_section148 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parameter_in_sectioncontent171 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_section_in_sectioncontent175 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_parameter186 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_COLON_in_parameter188 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_ID_in_parameter192 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_BRACKETLEFT_in_parameter194 = new BitSet(new long[]{0x0000000000001080L});
    public static final BitSet FOLLOW_attribute_in_parameter196 = new BitSet(new long[]{0x0000000000001080L});
    public static final BitSet FOLLOW_BRACKETRIGHT_in_parameter199 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_attribute225 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_COLON_in_attribute227 = new BitSet(new long[]{0x0000000000002002L});
    public static final BitSet FOLLOW_ATTRVALUE_in_attribute229 = new BitSet(new long[]{0x0000000000000002L});

}